const ProcurementOrderModel = require('../model/ProcurementOrderModel');
const GoodsModel = require('../model/GoodsModel');

class ProcurementOrderController {
    constructor() {
        // 实例化模型层
        this.orderModel = new ProcurementOrderModel();
        // 绑定所有方法的this指向当前实例
        this.getOrderList = this.getOrderList.bind(this);
        this.getOrderDetail = this.getOrderDetail.bind(this);
        this.createOrder = this.createOrder.bind(this);
        this.updateOrder = this.updateOrder.bind(this);
        // this.deleteOrder = this.deleteOrder.bind(this);
        this.updateOrderStatus = this.updateOrderStatus.bind(this);
        this.deleteOrderGoodsItem = this.deleteOrderGoodsItem.bind(this);
        this.deleteOrder = this.deleteOrder.bind(this);
        this.addOrderGoodsItem = this.addOrderGoodsItem.bind(this);

        // 实例化GoodsModel
        this.goodsModel = new GoodsModel();
        this.getGoodsListBySupplierId = this.getGoodsListBySupplierId.bind(this);
        this.updateGoodsInfo = this.updateGoodsInfo.bind(this);
    }

    /**
     * 统一响应处理方法
     * @param {Object} res - Express 响应对象
     * @param {number} code - HTTP状态码
     * @param {boolean} success - 操作结果
     * @param {string} message - 提示信息
     * @param {Object} data - 业务数据（可选）
     */
    sendResponse(res, code, success, message, data = null, customizeCode = 0) {
        res.status(code).json({
            code: customizeCode,
            msg: message,
            // 仅当 data 不为 null 时，才添加 data 属性   ...(data !== null ? { data: data } : false)
            ...(data !== null && { data })
        });
    }

    /**
     * 获取采购订单列表（支持筛选和分页）
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     */
    async getOrderList(req, res) {
        try {
            // 从查询参数中提取筛选条件（状态、日期、分页等）
            const queryParams = req.query;
            const result = await this.orderModel.getAllOrders(queryParams);
            this.sendResponse(res, 200, true, '采购订单列表获取成功', result);
        } catch (error) {
            console.error('获取订单列表失败：', error);
            this.sendResponse(res, 400, false, error.message || '获取订单列表失败', null, 1);
        }
    }

    /**
     * 根据ID获取采购订单详情
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     */
    async getOrderDetail(req, res) {
        try {
            // 从URL参数中获取订单ID
            const { orderId } = req.params;
            const orderDetail = await this.orderModel.getOrderById(orderId);

            if (!orderDetail) {
                return this.sendResponse(res, 404, false, `订单ID=${orderId}不存在`, null, 1);
            }

            this.sendResponse(res, 200, true, '采购订单详情获取成功', orderDetail);
        } catch (error) {
            console.error('获取订单详情失败：', error);
            this.sendResponse(res, 400, false, error.message || '获取订单详情失败', null, 1);
        }
    }

    /**
     * 创建新采购订单
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     */
    async createOrder(req, res) {
        try {
            // 从请求体获取订单数据（主表+明细）
            const orderData = req.body;

            // 基础参数校验（控制器层补充必要校验）
            if (!orderData.createdUid) {
                return this.sendResponse(res, 400, false, '创建人ID（createdUid）为必填项', null, 1);
            }
            if (!orderData.details || !Array.isArray(orderData.details) || orderData.details.length === 0) {
                return this.sendResponse(res, 400, false, '订单明细（details）必须为非空数组', null, 1);
            }

            // 调用模型层创建订单
            const result = await this.orderModel.createOrder(orderData);
            this.sendResponse(res, 200, true, '采购订单创建成功', result);
        } catch (error) {
            console.error('创建订单失败：', error);
            this.sendResponse(res, 400, false, error.message || '创建订单失败', null, 1);
        }
    }

    /**
     * 更新采购订单（主表字段+明细全量更新）
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     */
    async updateOrder(req, res) {
        try {
            const { orderId } = req.params; // 订单ID
            const updateData = req.body;   // 更新数据

            // 基础参数校验
            if (!updateData.updatedUid) {
                return this.sendResponse(res, 400, false, '更新人ID（updatedUid）为必填项', null, 1);
            }

            // 调用模型层更新订单
            const result = await this.orderModel.updateOrder(orderId, updateData);
            this.sendResponse(res, 200, true, '采购订单更新成功', result);
        } catch (error) {
            console.error('更新订单失败：', error);
            this.sendResponse(res, 400, false, error.message || '更新订单失败', null, 1);
        }
    }

    /**
     * 更新采购订单状态（单独接口，控制状态流转）
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     */
    async updateOrderStatus(req, res) {
        try {
            const { orderId } = req.params;
            const { status, operatorId, notes } = req.body;

            // 基础参数校验
            if (status === undefined) {
                return this.sendResponse(res, 400, false, '目标状态（status）为必填项', null, 1);
            }
            if (!operatorId) {
                return this.sendResponse(res, 400, false, '操作人ID（operatorId）为必填项', null, 1);
            }

            // 调用模型层更新状态
            const result = await this.orderModel.updateOrderStatus(orderId, status, operatorId, notes);
            this.sendResponse(res, 200, true, '采购订单状态更新成功', result);
        } catch (error) {
            console.error('更新订单状态失败：', error);
            this.sendResponse(res, 400, false, error.message || '更新订单状态失败', null, 1);
        }
    }

    /**
     * 根据供应商id获取食材档案列表
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     * @param {Array} supplierId - 供应商id数组
     */
    async getGoodsListBySupplierId(req, res) {
        const queryData = req.query;
        let supplierId = queryData.supplierId;
        console.log('A supplierId:', supplierId,typeof supplierId)
        // 提提供时返回空数据
        if(!supplierId||supplierId==undefined){
            return this.sendResponse(res, 200, false, '未提供供应商ids', []);
        }

        // 判断是否为数组
        if(Array.isArray(supplierId)) {
            supplierId = supplierId.map(id => parseInt(id));
        } else {
            supplierId = JSON.parse(supplierId); // 把string格式的数组转为数组
        }
        // 重新赋值
        queryData.supplierId = supplierId;

        try {
            const goodsList = await this.goodsModel.getGoodsListBySupplierIds(queryData);
            this.sendResponse(res, 200, true, '根据供应商食材列表成功', goodsList);
        } catch (error) {
            console.error('获取食材列表失败：', error);
            this.sendResponse(res, 400, false, error.message || '获取食材列表失败', null, 1);
        }
    }

    /**
     * 删除采购单明细中的食材
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     */
    async deleteOrderGoodsItem(req, res) {
        try {
            const { orderId, goodsId } = req.params; //delete方法推荐用params参数

            // 验证参数
            if (!orderId || !goodsId) {
                return this.sendResponse(res, 200, false, '参数错误', null, 1);
            }

            // 转换参数类型
            const OrderId = parseInt(orderId);
            const GoodsID = parseInt(goodsId);

            // 检查订单是否存在
            const order = await this.orderModel.checkOrderExists(parseInt(OrderId));
            if (!order) {
                return this.sendResponse(res, 200, false, `订单ID=${OrderId}不存在`, null, -1);
            }

            // 检查订单中的石材是否存在
            const items = await this.orderModel.checkOrderGoodsExists(parseInt(OrderId),parseInt(GoodsID));
            if (!items) {
                return this.sendResponse(res, 200, false, `订单ID${OrderId}下找不到ID为${GoodsID}的物品`, null, 1);
            }

            // 删除食材
            const result = await this.orderModel.deleteOrderGoods(parseInt(OrderId), parseInt(GoodsID));
            this.sendResponse(res, 200, true, '删除订单食材信息成功', result);
        } catch (err){
            console.error('删除订单食材明细失败：', err);
        }
    }

    /**
     * 删除采购单
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     */
    async deleteOrder(req, res) {
        try {
            const { orderId } = req.params;
           //检查订单是否存在
            const order = await this.orderModel.checkOrderExists(parseInt(orderId));
            if (!order) {
                return this.sendResponse(res, 400, false, `订单ID=${orderId}不存在`, null, -1);
            }

            //删除采购订单
            const result= await this.orderModel.deleteOrderRecord(parseInt(orderId));
            console.log('删除采购订单 result:',result)
            if (!result) {
                return this.sendResponse(res, 400, false, '删除采购单失败', null, 1);
            }
            this.sendResponse(res, 200, true, '删除采购单成功', result);
        } catch (err){
            console.error('删除采购单失败：', err);
        }
    }

    /**
     * 新增采购单中的食材
     * @param {Object} req - Express 请求对象
     * @param {Object} res - Express 响应对象
     */
    async addOrderGoodsItem(req, res) {
        try {
            // 1. 参数验证
            const { orderId } = req.params;
            const { goodsId, goodsCount, notes} = req.body;

            if (!orderId || !goodsId || !goodsCount){
                return this.sendResponse(res, 200, false, '缺少参数', null, -1);
            }

            // 2.检查商品是否存在这个 采购单中，已经存在则不允许添加
            const checkGoods = await this.orderModel.checkOrderGoodsExists2(
                parseInt(orderId),
                parseInt(goodsId)
            );

            console.log('检查商品是否存在这个 采购单中:', checkGoods)
            if (checkGoods) {
                return this.sendResponse(res, 200, false, '该食材已添加到该采购单中,请选其它商品!', null, 1);
            }

            //3.添加采购订单商品项
            const result = await this.orderModel.addOrderGoodsItem(
                parseInt(orderId),
                parseInt(goodsId),
                parseInt(goodsCount),
                notes
            );
            this.sendResponse(res, 200, true, '添加采购单食材成功!', result);
        } catch (err){
            console.error('新增采购单中的食材失败：', err);
        }
    }
    /*
    * @desc: 创建采购订单时，如修改了商品的采购价格，入库，出库，安全库存，则需要更新食材对应的信息
    * */
    async updateGoodsInfo(req, res) {
        try {
            const { goodsId } = req.params;
            const { inPrice, outPrice, safetyStock } = req.body;
            if (!goodsId || !inPrice || !outPrice || !safetyStock) {
                return this.sendResponse(res, 200, false, '缺少参数', null, -1);
            }
            const result = await this.goodsModel.updateGoods(goodsId, {
                in_price: inPrice,
                out_price: outPrice,
                safety_stock: safetyStock
            });
            this.sendResponse(res, 200, true, '更新食材信息成功!', result);
        } catch (err){
            console.error('更新食材信息失败：', err);
        }
    }
}

module.exports = new ProcurementOrderController();